import greenfoot.*;  
import java.util.*; 
/**
 * La clase Cronometro nos Imprime el tiempo que tiene el jugador
 * 
 * @author (Alcantar Noyola Christian Andres) 
 * @author (Sanchez Ovalle Daniel) 
 * @version (29/04/13)
 */

public class Cronometro extends Actor
{
    private Contador minutos;
    private Contador segundos;
    private Date tiempoInicial;
    private Date tiempoActual;
    private int tiempoTranscurrido;
    private int limiteMin;
    private int limiteSeg;
    private int totalSegundos;

    /**
     * Constructor del cronometro.
     * @param segundos es la cantidad de segundos con que inicia el cronometro.
     * (seran convertidos a minutos)
     */
    public Cronometro(int segundos)
    {
        totalSegundos=segundos;
        tiempoInicial=new Date();

        tiempoTranscurrido=0;
        if(segundos>0)
        {
            limiteMin=this.calculaTiempo(segundos);
        }
        else
        {
            limiteMin=0;
            limiteSeg=0;
        }
    }

    /**
     * Esta clase regresa los minutos del cronometro
     * @return regresa un entero que representa la cantidad de minutos del cronometro.
     */
    public int getMinutos()
    {
        return minutos.getValor();
    }

    /**
     * Esta clase regresa los segundos del cronometro
     * @return regresa un entero que representa la cantidad de segundos del cronometro.
     */
    public int getSegundos()
    {
        return segundos.getValor();
    }

    /**
     * Este metodo añade al mundo los minutos y segundos del cronometro del juego
     */
    public void addedToWorld(World mundo)
    {
        minutos=new Contador(limiteMin,mundo,368,20);
        segundos=new Contador(limiteSeg,mundo,438,20);
    }

    /**
     * Este metodo inicializa la cuenta del cronometro.
     */
    public void inicializaCuenta()
    {
        tiempoInicial=new Date();
        limiteMin=minutos.getValor();
        limiteSeg=segundos.getValor();
    }

    /**
     * En el metodo actuar se actualiza el tiempo del cronometro.
     */
    public void act()
    {
        if(minutos.getValor()<=0 && segundos.getValor()<=0 || limiteMin<=0 && limiteSeg<=0)
        {
            Escenario1 mundo=(Escenario1)this.getWorld();
            Jugador chango=mundo.getChango();
            Contador vidas=chango.getVidas();
            if(vidas.getValor()>0)
            {
                chango.setLocation(674,447);
                vidas.decrementarValor(1);
                limiteMin=this.calculaTiempo(totalSegundos);
                minutos.fijaValor(limiteMin);
                segundos.fijaValor(limiteSeg);
                this.inicializaCuenta();
            }
            else
            {
                chango.incrementaPuntos();
                mundo.prepare(3);
            }

        }
        else
            this.actualizaTiempo();
    }

    /**
     * Este metodo actualiza el valor del cronometro.
     */
    public void actualizaTiempo()
    {
        tiempoActual=new Date();
        tiempoTranscurrido=(int)(tiempoActual.getTime()-tiempoInicial.getTime())/1000;
        if(limiteMin*60+limiteSeg >= tiempoTranscurrido)
            this.restaSegundos(tiempoTranscurrido);
        else
        {
            minutos.fijaValor(0);
            segundos.fijaValor(0);
        }
    }

    /**
     * Este metodo resta los segundos del cronometro
     * @param segs recibe un entero que son los segundos que se le van a restar al cronometro
     */
    public void restSegs(int segs)
    {     
        limiteSeg=limiteSeg-segs;
        limiteMin=limiteMin-this.calculaTiempo(limiteSeg);
    }

    /**
     * Este metodo se encarga de calcular el tiempo en mnutos y segundos que hay en una cantidad de segundos.
     * @param segundos es la cantidad de segundos que se calcularan.
     */
    public int calculaTiempo(int segundos)
    {
        int min=0;
        int segs=0;
        segs=segundos;
        if(segs>0)
        {
            while(segs>59)
            {
                segs=segs-60;
                min=min+1;
            }
        }
        else
        {
            while(segs<0)
            {
                segs=segs+60;
                min=min+1;
            }
        }
        limiteSeg=segs;
        return min;
    }

    /**
     * Este metodo realiza el decremento del tiempo del cronometro.
     * @param segs es la cantidad de segundos que se restaran al cronometro.
     */
    public void restaSegundos(int segs)
    {
        int minrestantes;
        int segrestantes;
        int min=0;

        minrestantes=limiteMin;
        if(minrestantes>0)
        {
            segrestantes=limiteSeg-segs;
            while(segrestantes<0)
            {
                segrestantes=segrestantes+60;
                min=min+1;
            }
            minrestantes=limiteMin-min;
        }
        else
        {
            segrestantes=limiteSeg-segs;
            if(segrestantes<0)
                segrestantes=0;
        }

        minutos.fijaValor(minrestantes);
        segundos.fijaValor(segrestantes);
    }
}